package com.petdog.module.recognition.provider;

import com.petdog.module.recognition.dto.RecognitionResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

/**
 * AI服务提供者
 * 负责对接AI模型进行犬种识别
 * 注：当前实现为模拟识别结果，实际应用中应替换为真实的AI模型调用
 */
@Component
public class AIProvider {

    private static final Logger logger = LoggerFactory.getLogger(AIProvider.class);
    
    // 模拟犬种数据
    private static final List<String> BREED_NAMES = Arrays.asList(
            "金毛犬", "拉布拉多", "德国牧羊犬", "边境牧羊犬", "柯基犬", 
            "萨摩耶", "哈士奇", "贵宾犬", "比熊犬", "松狮犬",
            "巴哥犬", "雪纳瑞", "可卡犬", "吉娃娃", "西施犬"
    );
    
    private final Random random = new Random();

    /**
     * 犬种识别方法
     * @param imageFile 上传的图像文件
     * @return 识别结果列表，按置信度降序排列
     */
    public List<RecognitionResult> recognizeBreed(MultipartFile imageFile) {
        logger.info("开始犬种识别，文件名: {}", imageFile.getOriginalFilename());
        
        try {
            // 1. 验证文件
            validateImageFile(imageFile);
            
            // 2. 读取和分析图像
            BufferedImage image = readAndAnalyzeImage(imageFile);
            
            // 3. 进行犬种识别（模拟）
            List<RecognitionResult> results = simulateBreedRecognition(image);
            
            logger.info("犬种识别完成，识别出 {} 个可能的犬种", results.size());
            return results;
            
        } catch (IOException e) {
            logger.error("图像读取失败: {}", e.getMessage(), e);
            return null;
        } catch (Exception e) {
            logger.error("犬种识别过程中发生错误: {}", e.getMessage(), e);
            return null;
        }
    }
    
    /**
     * 验证图像文件
     */
    private void validateImageFile(MultipartFile imageFile) {
        if (imageFile == null || imageFile.isEmpty()) {
            throw new IllegalArgumentException("上传的文件为空");
        }
        
        // 检查文件类型
        String contentType = imageFile.getContentType();
        if (contentType == null || !contentType.startsWith("image/")) {
            throw new IllegalArgumentException("不支持的文件格式，仅支持JPEG、PNG、WEBP");
        }
        
        // 检查文件大小
        if (imageFile.getSize() > 8 * 1024 * 1024) {
            throw new IllegalArgumentException("文件大小不能超过8MB，请压缩后重新上传");
        }
    }
    
    /**
     * 读取和分析图像
     */
    private BufferedImage readAndAnalyzeImage(MultipartFile imageFile) throws IOException {
        BufferedImage image = ImageIO.read(imageFile.getInputStream());
        
        if (image == null) {
            throw new IOException("无法识别的图像格式");
        }
        
        // 获取图像尺寸
        int width = image.getWidth();
        int height = image.getHeight();
        
        logger.info("图像尺寸: {}x{}", width, height);
        
        // 检查分辨率
        if (width < 50 || height < 50) {
            logger.warn("图片分辨率过低，可能影响识别效果，建议上传≥200×200px的图片");
        }
        
        // 可以在这里添加图像预处理逻辑
        return image;
    }
    
    /**
     * 模拟犬种识别结果
     * 注：实际应用中应替换为真实的AI模型调用
     */
    private List<RecognitionResult> simulateBreedRecognition(BufferedImage image) {
        List<RecognitionResult> results = new ArrayList<>();
        
        // 随机生成3-5个犬种结果
        int numResults = 3 + random.nextInt(3);
        
        // 确保不会重复选择同一个犬种
        List<String> selectedBreeds = new ArrayList<>();
        
        for (int i = 0; i < numResults; i++) {
            String breedName;
            do {
                int breedIndex = random.nextInt(BREED_NAMES.size());
                breedName = BREED_NAMES.get(breedIndex);
            } while (selectedBreeds.contains(breedName));
            
            selectedBreeds.add(breedName);
            
            RecognitionResult result = new RecognitionResult();
            result.setBreedId(i + 1); // 假设ID从1开始
            result.setBreedName(breedName);
            
            // 生成合理的置信度，第一个结果的置信度最高
            float confidence;
            if (i == 0) {
                confidence = 0.7f + random.nextFloat() * 0.3f; // 70%-100%
            } else if (i == 1) {
                confidence = 0.4f + random.nextFloat() * 0.3f; // 40%-70%
            } else {
                confidence = 0.1f + random.nextFloat() * 0.3f; // 10%-40%
            }
            
            // 保留三位小数
            result.setConfidence(Math.round(confidence * 1000) / 1000.0f);
            results.add(result);
        }
        
        // 按置信度降序排序
        results.sort((a, b) -> Float.compare(b.getConfidence(), a.getConfidence()));
        
        return results;
    }
}
